package main

import (
	"fmt"
)

func main() {
	//数组类型：元素类型，长度。两种条件都相同的是同种类型数组
	var a1 [3]int
	var a2 [3]int
	var a22 [3]*int
	a1 = a2
	fmt.Println(a1)
	fmt.Println(a22)
	fmt.Println(a1 == a2) //数组比较，前提是同种类型的数组

	b := [4]int{1, 2, 3}
	fmt.Println(b)

	c := [...]int{1, 2, 3, 5: 100} //在不确定数组长度时，用[...]来表示该数组是可扩容的。
	fmt.Println(c)

	type stu struct {
		name string
		age  int
	}

	s1 := stu{
		name: "xww",
		age:  11,
	}
	s2 := stu{
		name: "xww",
		age:  12,
	}
	d1 := []stu{
		s1,
		s2,
	}
	d2 := []stu{
		{"xww1", 11},
		{"xww2", 12},
	}
	fmt.Println(d1)
	fmt.Println(d2)
	//多维数组
	e1 := [2][2]int{
		{1, 2}, {3, 4},
	}
	fmt.Println(e1)
	/*e2 := [2][...]int{
		{1, 2, 3, 5}, {3, 4},
	}*/                //列数是不能省略的，也就是第二个维度不能省略
	e2 := [...][2]int{ //第一个维度（行数）可以省略用“...”来替代
		{1, 2}, {3, 4}, {4, 5},
	}
	fmt.Println(e2)

	fmt.Println(len(d2))
	fmt.Println(len(e2))
	fmt.Println(cap(e2)) //容量

	//指针数组（其实就是数组，并不存在这样的叫法）    数组指针（就是指针，指针指向数组而已，也没这样叫法）  两种都是忽悠人的

	x, y := 10, 20
	z := [...]*int{&x, &y}
	p := &z
	fmt.Println(z)
	fmt.Println(p)

	//数组拷贝
	f := [2]int{11, 22}
	var g [2]int
	g = f
	fmt.Printf("x:%p,%v \n", &f, f)
	fmt.Printf("x:%p,%v \n", &g, g)

	test(&f)
	fmt.Println(f)
}

func test(x *[2]int) { //如果传入的数组元素非常庞大，则会占用很多内存空间，影响性能，所以通常传入的是指针
	fmt.Printf("x:%p,%v \n", &x, x)
	x[0] = 1111
}
